#include "../Server.hpp"


void EstablishHandler(ConnectionPtr conn)
{
    DEBUG_LOG("new connection:%p", conn.get());
}

void MessageHandler(ConnectionPtr conn, Buffer *inbuffer)
{
    // 把数据读出来处理
    char buffer[65536] = {0};
    inbuffer->Read(buffer, inbuffer->ReadSize());
    // 打印一下收到的内容
    DEBUG_LOG("收到：%s", buffer);
    // 处理数据
    std::string msg = "Hello World";
    // 发送回去
    conn->SendInLoop(msg.c_str(), msg.size());
    //conn->DisConnectInLoop();
}

void CloseHandler(ConnectionPtr conn)
{
    DEBUG_LOG("close conn %p",conn.get());
}


//测试TcpServer模块
int main()
{
    TcpServer tcp_server(8080,2);
    tcp_server.EnableTimeoutRelease(10);
    tcp_server.SetEstablishCallback(EstablishHandler);    
    tcp_server.SetMsgHandlerCallback(MessageHandler);
    tcp_server.SetReleaseCallback(CloseHandler);
    tcp_server.Start();
    return 0;
}




 





//-----------------------------------------------------------------------------
// uint64_t connect_id = 0;
// std::unordered_map<uint64_t, ConnectionPtr> _conns; // 服务器管理连接的容器
// EventLoop main_loop;
// LoopThreadPool *loop_thread_pool;

// // 测试LoopThreadPool模块
// // 上层传给Connection的回调，参数由Connection内部提供了
// void MessageHandler(ConnectionPtr conn, Buffer *inbuffer)
// {
//     // 把数据读出来处理
//     char buffer[65536] = {0};
//     inbuffer->Read(buffer, inbuffer->ReadSize());
//     // 打印一下收到的内容
//     DEBUG_LOG("收到：%s", buffer);
//     // 处理数据
//     std::string msg = "Hello World";
//     // 发送回去
//     conn->SendInLoop(msg.c_str(), msg.size());
// }
// // 连接关闭时调用的模块（用于服务器删除ConnectionPtr）
// void ServerCloseHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("close connection:%p", conn.get());
//     _conns.erase(conn->Id());
// }

// void AnyHandler(ConnectionPtr conn)
// {
// }
// void EstablishHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("new connection:%p", conn.get());
// }

// // 获取新连接，为新连接创建Channel添加监控(这里先不用Socket，直接使用fd 与 accpet测试)
// void AcceptHandler(int newfd)
// {
    
//     // 为新连接创建Connection
//     ConnectionPtr new_sock_connection(new Connection(connect_id, newfd, loop_thread_pool->SelectOneLoop()));
//     // 为通信套接字设置回调
//     new_sock_connection->SetMsgHandlerCallback(std::bind(MessageHandler, std::placeholders::_1, std::placeholders::_2));
//     new_sock_connection->SetServReleaseCallback(std::bind(ServerCloseHandler, std::placeholders::_1));
//     new_sock_connection->SetAnyEventCallback(std::bind(AnyHandler, std::placeholders::_1));
//     new_sock_connection->SetEstablishCallback(std::bind(EstablishHandler, std::placeholders::_1));
//     new_sock_connection->EnableTimeoutReleaseInLoop(10); // 开启定时销毁任务
//     // 初始化连接，设置读事件监控，设置了监控之后
//     new_sock_connection->EstablishInLoop();
//     // 创建好之后，插入进去
//     _conns.insert(std::make_pair(connect_id, new_sock_connection));
// }

// int main()
// {
//     loop_thread_pool = new LoopThreadPool(&main_loop);
//     loop_thread_pool->CreateThreadLoops(2);

//     Acceptor acceptor(&main_loop, 8080);
//     acceptor.SetAcceptCallback(std::bind(AcceptHandler, std::placeholders::_1));
//     acceptor.ReadCareListen();
//     main_loop.Start();
// }

// uint64_t connect_id = 0;
// std::unordered_map<uint64_t, ConnectionPtr> _conns; // 服务器管理连接的容器
// EventLoop main_loop;
// std::vector<LoopThread> threads(2);
// int next_loop = 0;

// // 测试ThreadLoop模块
// // 上层传给Connection的回调，参数由Connection内部提供了
// void MessageHandler(ConnectionPtr conn, Buffer *inbuffer)
// {
//     // 把数据读出来处理
//     char buffer[65536] = {0};
//     inbuffer->Read(buffer, inbuffer->ReadSize());
//     // 打印一下收到的内容
//     DEBUG_LOG("收到：%s", buffer);
//     // 处理数据
//     std::string msg = "Hello World";
//     // 发送回去
//     conn->SendInLoop(msg.c_str(), msg.size());
// }
// // 连接关闭时调用的模块（用于服务器删除ConnectionPtr）
// void ServerCloseHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("close connection:%p", conn.get());
//     _conns.erase(conn->Id());
// }

// void AnyHandler(ConnectionPtr conn)
// {
// }
// void EstablishHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("new connection:%p", conn.get());
// }

// // 获取新连接，为新连接创建Channel添加监控(这里先不用Socket，直接使用fd 与 accpet测试)
// void AcceptHandler(int newfd)
// {
//     connect_id++;
//     next_loop = (next_loop + 1) % 2;//轮询两个loop线程
//     // 为新连接创建Connection
//     ConnectionPtr new_sock_connection(new Connection(connect_id, newfd,threads[next_loop].GetEventLoop()));
//     // 为通信套接字设置回调
//     new_sock_connection->SetMsgHandlerCallback(std::bind(MessageHandler, std::placeholders::_1, std::placeholders::_2));
//     new_sock_connection->SetServReleaseCallback(std::bind(ServerCloseHandler, std::placeholders::_1));
//     new_sock_connection->SetAnyEventCallback(std::bind(AnyHandler, std::placeholders::_1));
//     new_sock_connection->SetEstablishCallback(std::bind(EstablishHandler, std::placeholders::_1));
//     new_sock_connection->EnableTimeoutReleaseInLoop(10); // 开启定时销毁任务
//     // 初始化连接，设置读事件监控，设置了监控之后
//     new_sock_connection->EstablishInLoop();
//     // 创建好之后，插入进去
//     _conns.insert(std::make_pair(connect_id, new_sock_connection));
// }

// int main()
// {
//     srand((unsigned int)time(nullptr));
//     Acceptor acceptor(&main_loop, 8080);
//     acceptor.SetAcceptCallback(std::bind(AcceptHandler, std::placeholders::_1));
//     acceptor.ReadCareListen();
//     // 循环等待
//     while (1)
//     {
//         main_loop.Start();
//     }
// }

// uint64_t connect_id = 0;
// std::unordered_map<uint64_t, ConnectionPtr> _conns; // 服务器管理连接的容器
// EventLoop event_loop;
// // 测试Acceptor模块
// // 上层传给Connection的回调，参数由Connection内部提供了
// void MessageHandler(ConnectionPtr conn, Buffer *inbuffer)
// {
//     // 把数据读出来处理
//     char buffer[65536] = {0};
//     inbuffer->Read(buffer, inbuffer->ReadSize());
//     // 打印一下收到的内容
//     DEBUG_LOG("收到：%s", buffer);
//     // 处理数据
//     std::string msg = "Hello World";
//     // 发送回去
//     conn->SendInLoop(msg.c_str(), msg.size());
// }
// // 连接关闭时调用的模块（用于服务器删除ConnectionPtr）
// void ServerCloseHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("close connection:%p", conn.get());
//     _conns.erase(conn->Id());
// }

// void AnyHandler(ConnectionPtr conn)
// {
// }
// void EstablishHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("new connection:%p", conn.get());
// }

// // 获取新连接，为新连接创建Channel添加监控(这里先不用Socket，直接使用fd 与 accpet测试)
// void AcceptHandler(int newfd)
// {
//     // 为新连接创建Connection
//     ConnectionPtr new_sock_connection(new Connection(connect_id, newfd, &event_loop));
//     // 为通信套接字设置回调
//     new_sock_connection->SetMsgHandlerCallback(std::bind(MessageHandler, std::placeholders::_1, std::placeholders::_2));
//     new_sock_connection->SetServReleaseCallback(std::bind(ServerCloseHandler, std::placeholders::_1));
//     new_sock_connection->SetAnyEventCallback(std::bind(AnyHandler, std::placeholders::_1));
//     new_sock_connection->SetEstablishCallback(std::bind(EstablishHandler, std::placeholders::_1));
//     new_sock_connection->EnableTimeoutReleaseInLoop(10); // 开启定时销毁任务
//     // 初始化连接，设置读事件监控，设置了监控之后
//     new_sock_connection->EstablishInLoop();
//     // 创建好之后，插入进去
//     _conns.insert(std::make_pair(connect_id, new_sock_connection));
//     connect_id++;
// }

// int main()
// {
//     srand((unsigned int)time(nullptr));
//     Acceptor acceptor(&event_loop, 8080);
//     acceptor.SetAcceptCallback(std::bind(AcceptHandler,std::placeholders::_1));
//     acceptor.ReadCareListen();
//     // 循环等待
//     while (1)
//     {
//         event_loop.Start();
//     }
// }

// uint64_t connect_id = 0;
// std::unordered_map<uint64_t,ConnectionPtr> _conns;//服务器管理连接的容器

// // 测试Connection模块
// //上层传给Connection的回调，参数由Connection内部提供了
// void MessageHandler(ConnectionPtr conn,Buffer* inbuffer)
// {
//     //把数据读出来处理
//     char buffer[65536] = {0};
//     inbuffer->Read(buffer,inbuffer->ReadSize());
//     //打印一下收到的内容
//     DEBUG_LOG("收到：%s",buffer);
//     //处理数据
//     std::string msg = "Hello World";
//     //发送回去
//     conn->SendInLoop(msg.c_str(),msg.size());
// }
// //连接关闭时调用的模块（用于服务器删除ConnectionPtr）
// void ServerCloseHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("close connection:%p",conn.get());
//     _conns.erase(conn->Id());
// }

// void AnyHandler(ConnectionPtr conn)
// {

// }
// void EstablishHandler(ConnectionPtr conn)
// {
//     DEBUG_LOG("new connection:%p",conn.get());
// }

// // 获取新连接，为新连接创建Channel添加监控(这里先不用Socket，直接使用fd 与 accpet测试)
// void Accept(EventLoop *event_loop, Channel *lis_sock_channel)
// {
//     int fd = lis_sock_channel->Fd();
//     int newfd = accept(fd, nullptr, nullptr);
//     if (newfd < 0)
//         return;

//     // 为新连接创建Connection
//     ConnectionPtr new_sock_connection(new Connection(connect_id, newfd, event_loop));
//     // 为通信套接字设置回调
//     new_sock_connection->SetMsgHandlerCallback(std::bind(MessageHandler,std::placeholders::_1,std::placeholders::_2));
//     new_sock_connection->SetServReleaseCallback(std::bind(ServerCloseHandler, std::placeholders::_1));
//     new_sock_connection->SetAnyEventCallback(std::bind(AnyHandler, std::placeholders::_1));
//     new_sock_connection->SetEstablishCallback(std::bind(EstablishHandler, std::placeholders::_1));
//     new_sock_connection->EnableTimeoutReleaseInLoop(10);//开启定时销毁任务
//     //初始化连接，设置读事件监控，设置了监控之后
//     new_sock_connection->EstablishInLoop();
//     //创建好之后，插入进去
//     _conns.insert(std::make_pair(connect_id,new_sock_connection));
//     connect_id++;
// }

// int main()
// {
//     srand((unsigned int)time(nullptr));
//     EventLoop event_loop;
//     TcpSocket listen_socket;
//     listen_socket.ServerCreate(8080, false);
//     // 给监听套接字构建Channel
//     Channel lis_sock_channel(listen_socket.Fd(), &event_loop);
//     // 设置回调函数
//     lis_sock_channel.SetReadCallback(std::bind(Accept, &event_loop, &lis_sock_channel)); // 获取新连接，为新连接创建Channel添加监控
//     // 监控可读事件
//     lis_sock_channel.SetReadCare();

//     // 循环等待
//     while (1)
//     {
//         std::vector<Channel *> ready_channels;
//         event_loop.Start(ready_channels);
//     }

//     listen_socket.Close();
// }

// void CloseHandler(Channel *channel)
// {
//     //std::cout << "close fd:" << channel->Fd() << std::endl;
//     DEBUG_LOG("close fd = %d",channel->Fd());
//     channel->DeleteFd(); // 移除监控
//     close(channel->Fd());
//     delete channel;
// }

// void ReadHandler(Channel *channel)
// {
//     int fd = channel->Fd();
//     char buffer[1024] = {0};
//     int n = recv(fd, buffer, sizeof(buffer) - 1, 0);
//     if (n <= 0)
//     {
//         CloseHandler(channel); // 关闭sockfd
//         return;
//     }
//     else
//     {
//         // 读取成功，打印一下读到的数据
//         //std::cout << buffer << std::endl;
//         DEBUG_LOG("%s",buffer);
//         // 可以选择直接写，也可以添加写事件的监控
//         channel->SetWriteCare();
//     }
// }

// void WriteHandler(Channel *channel)
// {
//     int fd = channel->Fd();
//     // 发送数据
//     std::string msg = "You are pretty!";
//     int n = send(fd, msg.c_str(), msg.size(), 0);
//     if (n <= 0)
//     {
//         CloseHandler(channel);
//     }
//     else
//     {
//         // 发送成功，关闭对写的监控
//         channel->CancelWirteCare();
//     }
// }

// void ErrorHandler(Channel *channel)
// {
//     CloseHandler(channel);
// }

// // 任意事件的处理为：刷新连接活跃度-刷新定时任务
// void AnyHandler(Channel *channel,EventLoop* event_loop,uint64_t id)
// {
//     //DEBUG_LOG("AnyHandler");
//     event_loop->RefreshTimeTask(id);
// }

// void Print()
// {
//     DEBUG_LOG("debug");
// }

// // 获取新连接，为新连接创建Channel添加监控(这里先不用Socket，直接使用fd 与 accpet测试)
// void Accept(EventLoop *event_loop, Channel *lis_sock_channel)
// {
//     int fd = lis_sock_channel->Fd();
//     int newfd = accept(fd, nullptr, nullptr);
//     if (newfd < 0)
//         return;

//     uint64_t timer_id = rand()%10000;
//     // 为新连接创建Channel添加监控
//     Channel *new_sock_channel = new Channel(newfd, event_loop);
//     // 为通信套接字设置回调
//     new_sock_channel->SetReadCallback(std::bind(ReadHandler, new_sock_channel));
//     new_sock_channel->SetWriteCallback(std::bind(WriteHandler, new_sock_channel));
//     new_sock_channel->SetCloseCallback(std::bind(CloseHandler, new_sock_channel));
//     new_sock_channel->SetErrorCallback(std::bind(ErrorHandler, new_sock_channel));
//     //Channel *channel,EventLoop* event_loop,uint64_t id
//     new_sock_channel->SetAnyCallback(std::bind(AnyHandler, new_sock_channel,event_loop,timer_id));
//     // 添加新连接超时释放的任务(10秒后关闭连接)
//     //定时器销毁任务应该在启动读事件关心之前，因为可能启动监控后，立即有了事件，调用任意事件刷新，但是还没超时任务
//     event_loop->AddTimeTask(timer_id,10,std::bind(CloseHandler,new_sock_channel));
//     //event_loop->AddTimeTask(timer_id,5,std::bind(Print));

//     // 添加监控
//     new_sock_channel->SetReadCare();

// }

// int main()
// {
//     srand((unsigned int)time(nullptr));

//     //测试EventLoop与Channel
//     EventLoop event_loop;
//     TcpSocket listen_socket;
//     listen_socket.ServerCreate(8080, false);
//     // 给监听套接字构建Channel
//     Channel lis_sock_channel(listen_socket.Fd(), &event_loop);
//     // 设置回调函数
//     lis_sock_channel.SetReadCallback(std::bind(Accept, &event_loop, &lis_sock_channel)); // 获取新连接，为新连接创建Channel添加监控
//     // 监控可读事件
//     lis_sock_channel.SetReadCare();

//     // 循环等待
//     while (1)
//     {
//         std::vector<Channel *> ready_channels;
//         event_loop.Start(ready_channels);
//     }

//     //测试Epoller与Channel
//     // // 创建Epoll模型
//     // Epoller epoller;
//     // TcpSocket listen_socket;
//     // listen_socket.ServerCreate(8080, false);
//     // // 给监听套接字构建Channel
//     // Channel lis_sock_channel(listen_socket.Fd(), &epoller);
//     // // 设置回调函数
//     // lis_sock_channel.SetReadCallback(std::bind(Accept, &epoller, &lis_sock_channel)); // 获取新连接，为新连接创建Channel添加监控
//     // // 监控可读事件
//     // lis_sock_channel.SetReadCare();

//     // // 循环等待
//     // while (1)
//     // {
//     //     std::vector<Channel *> ready_channels;
//     //     epoller.WaitRun(ready_channels);
//     //     for (auto &channel : ready_channels)
//     //     {
//     //         channel->EventHandler();
//     //     }
//     // }

//     // 测试缓冲区
//     // while (true)
//     // {
//     //     int newfd = listen_socket.Accept();
//     //     if (newfd < 0)
//     //         continue;
//     //     TcpSocket new_client(newfd);
//     //     char buffer[1024];
//     //     int ret = new_client.Recv(buffer, sizeof(buffer) - 1);
//     //     if (ret < 0)
//     //     {
//     //         new_client.Close();
//     //         break;
//     //     }
//     //     else
//     //     {
//     //         buffer[ret] = 0;
//     //         new_client.Send(buffer, sizeof(buffer));
//     //         new_client.Close();
//     //     }
//     // }

//     listen_socket.Close();
// }
